//求任意两个数的最小值
function minNum(a, b) {
  return a > b ? b : a
}

//求任意两个数的最大值
function maxNum(a, b) {
  return a > b ? a : b
}

//求任意多个数的最小值
function anyMin() {
  var min = arguments[0];
  for (var i = 0; i < arguments.length; i++) {
    if (min > arguments[i]) {
      min = arguments[i]
    }
  }
  return min;
}

//求任意多个数的最大值
function anyMax() {
  var max = arguments[0];
  for (var i = 0; i < arguments.length; i++) {
    if (max < arguments[i]) {
      max = arguments[i]
    }
  }
  return max;
}

//求任意两个数之间的随机数 任意输入两个数值作为参数即可
function randomNum(n, m) {
  let min = n < m ? n : m; //最小值
  let max = n > m ? n : m //最大值
  return parseInt((Math.random() * (max - min + 1) + min))
}

//封装一个16进制的随机颜色函数  直接调用randomColor() 在前面拼接 '#'即可，就可以赋值给一个样式
function randomColor() {
  let num1 = 0x000000; //最黑的颜色 十六进制
  let num2 = 0xffffff; //最亮的颜色  十六进制
  n1 = num1.toString(10); //转化为10进制
  n2 = num2.toString(10); //转化为10进制
  let res = randomNum(n1, n2) //这是调用了随机函数
  return res = res.toString(16);
}

//封装格式化时间函数  参数data是为获取到的系统当前时间： var date = new Date();  把date当做参数传递进去！
function formatTime() {
  let date = new Date();
  let year = date.getFullYear();
  let month = date.getMonth() + 1;
  let date0 = date.getDate();
  let hours = date.getHours();
  let minutes = date.getMinutes();
  let seconds = date.getSeconds();
  let week = date.getDay();
  let arr = ['星期天', "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"]
  return "今年是：" + year + "的" + month + "月 " + date0 + "号 " + hours + "小时 " + minutes + "分钟 " + seconds + "秒 " +
    arr[week]; //今年是：2020的6月19号15小时3分钟42秒周5 ....
}

//封装一个求两个时间的时间差  
//参数1为获取当前时间 --- let time1 = new Date();  //当前时间 2020-06-19 20:13:43
//参数2为用户输入的时间 --- let time2 = new Date("2020-6-20 20:50:33");
//参数3：回调函数 callback为形参 然后在这边callback(obj) obj为实参，
// 调用函数后，把obj作用实参传递在外面的回调函数之中（一般使用value作为形参） 然后使用value['day']等来拿去内部的变量
function timeDifference(date1, date2, callback) {
  var time1 = date1.getTime(); //得到是 date1到格林威治时间的毫秒数
  var time2 = date2.getTime(); //得到是 date2到格林威治时间的毫秒数

  let times = Math.abs(time2 - time1); //求得两个时间的总毫秒数
  let day = parseInt(times / 1000 / 60 / 60 / 24);
  let h = parseInt((times / 1000 / 60 / 60) % 24)
  h = h < 10 ? +"0" + h : h
  let m = parseInt((times / 1000 / 60) % 60)
  m = m < 10 ? "0" + m : m
  let s = parseInt((times / 1000) % 60)
  s = s < 10 ? "0" + s : s
  let obj = {
    day: day,
    h: h,
    m: m,
    s: s,
  }
  callback(obj)
  // return "两个时间的时间差为：" + day + "天" + h + "小时" + m + "分钟" + s + "秒"
}

//秒杀时间函数
function killTime(date1, date2) {
  var time1 = date1.getTime(); //得到是 date1到格林威治时间的毫秒数
  var time2 = date2.getTime(); //得到是 date2到格林威治时间的毫秒数

  let times = Math.abs(time2 - time1); //求得两个时间的总毫秒数
  let day = parseInt(times / 1000 / 60 / 60 / 24);
  day = day < 10 ? "0" + day : day
  let h = parseInt((times / 1000 / 60 / 60) % 24)
  h = h < 10 ? "0" + h : h
  let m = parseInt((times / 1000 / 60) % 60)
  m = m < 10 ? "0" + m : m
  let s = parseInt((times / 1000) % 60)
  s = s < 10 ? "0" + s : s

  return day + ":" + h + ":" + m + ":" + s
}

//封装一个字符串转化对象的函数 参数为字符串str
//把字符串：var str = 'id=1&name=zhangsan&age=18&className=2003' 
//转化为对象：{id: "1", name: "zhangsan", age: "18", className: "2003"} 
function StringToObject(str) {
  let res = str.split("&")
  let newArr = []
  let obj = {}
  for (var i = 0; i < res.length; i++) {
    newArr = res[i].split("="); //id=1 - ["id", "1"]
    obj[newArr[0]] = newArr[1]
  }
  return obj
}

//封装一个对象转化为字符串的函数 参数为对象obj
//把对象： {id: "1", name: "zhangsan", age: "18", className: "2003"} 
//转化为字符串 ：var str = 'id=1&name=zhangsan&age=18&className=2003' 
function objectToString(obj) {
  let str = "";
  for (var k in obj) {
    str += k + "=" + obj[k] + "&"
  }
  return str.substr(0, str.length - 1)
}

//封装一个绑定事件函数
//参数1:ele -- 需要绑定的事件源； 参数2 type: ---事件类型（不需要添加on)； 参数3：回调函数（处理事件的函数）
function addEvent(ele, type, callback) {
  if (ele.addEventListener) {
    ele.addEventListener(type, function () {
      callback()
    })
  } else {
    ele.attachEvent("on" + type, function () {
      callback()
    })
  }
}

//封装一个获取非行内样式的函数  --- getStyle(box, 'height')
//参数1：为需要获取的元素，参数2：为获取元素的属性（需要添加'')  返回值：为style
function getStyle(ele, attr) {
  var style;
  if (ele.currentStyle) {
    // ele.currentStyle 包含 所有css样式的对象 需要使用obj['属性']
    style = ele.currentStyle[attr]
  } else {
    style = window.getComputedStyle(ele)[attr]
  }
  return style
}

//动画：animation(ele, obj, callback)
//参数1：为需要运动的元素 ； 参数2：为元素的属性的修改，以对象的形式（注意点：透明度设置为0.5  则需要0.5 * 100）
//参数3：为回调函数，就是待动画执行完毕后，需要操作
function animation(ele, obj, callback) {

  let timerLen = 0; //定时器的执行次数
  //遍历对象obj 进行动画样式的设置!
  for (let key in obj) {
    timerLen++
    // console.log(key); //字符串的格式 key --属性 top等等
    // console.log(obj[key]); //也就是目标值 属性值  obj[key] 100
    //style就是所运动的样式
    clearInterval(ele[key]) //清除上一次的定时器

    let speed = 0; //速度
    ele[key] = setInterval(() => {

      //假如为透明属性的时候，就获取到初始的透明值，否则就是获取当前样式的属性！
      if (key === "opacity") {
        //属性值的初始设置为小于1的，为透明度的时候 值需要*100，为了方便计算！
        style = getStyle(ele, key) * 100 //拿到初始的属性值 
      } else {
        var style = parseInt(getStyle(ele, key)); //获取到非行内样式  
      }
      //速度的计算！ (目标值 - 当前样式值)/5
      speed = (obj[key] - style) / 5;

      //假如速度小于0的时候，就是代表负数，向下取整（负数）
      speed = speed > 0 ? Math.ceil(speed) : Math.floor(speed);
      style = style + speed //所修改的样式 = 当前样式 + 速度

      // console.log(style, obj[key]); //50 100
      if (key === "opacity") { //由于透明属性没有那个单位，因此需要判断！
        ele.style[key] = style / 100 //修改ele元素的样式
      } else {
        ele.style[key] = style + "px" //修改ele元素的样式
      }

      if (style === obj[key]) { //当left等于目标值的之后，就清除定时器！
        clearInterval(ele[key])
        timerLen-- //执行完定时器后，就定时器计数渐渐 当定时器计数器为0的时候，代表动画执行结束
        if (timerLen === 0) {
          // console.log("动画执行完毕了");
          callback()
        }
      }
    }, 30)
  }
}